{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FNdZ-kD0l78P"
   },
   "source": [
    "# Kod Dil Modelini Tek GPU'da Fine-Tune Etmek\n",
    "\n",
    "_Yazar: [Maria Khalusova](https://github.com/MKhalusova)_\n",
    "\n",
    "_Çeviren: [Emre Albayrak](https://github.com/emre570)_\n",
    "\n",
    "Codex, StarCoder ve Code Llama gibi açık kaynak dil modelleri genel programlama ilkelerine ve sözdizimine uygun kod üretme konusunda harikadırlar. Fakat bu modeller, bir kuruluşun dahili kurallarıyla uyumlu olmayabilir veya özel kütüphanelerden haberdar olmayabilir.\n",
    "\n",
    "Bu notebook'ta, bir modelin bağlamsal farkındalığını artırmak ve kuruluşunuzun ihtiyaçları için kullanılabilirliğini artırmak amacıyla özel kod tabanlarında bir kod dil modeline nasıl fine-tune yapabileceğinizi göstereceğiz. Kod dil modelleri oldukça büyük olduğundan, geleneksel bir şekilde fine-tune yapmak kaynakları tüketebilir. Endişelenmeyin! Fine-tune işlemini tek bir GPU'ya sığacak şekilde nasıl optimize edebileceğinizi göstereceğiz.\n",
    "\n",
    "\n",
    "## Veri Seti\n",
    "\n",
    "Bu örnek için GitHub'daki en iyi 10 Hugging Face public repo'larını seçtik. Görseller, ses dosyaları, sunumlar gibi kod içermeyen dosyaları verilerden hariç tuttuk. Jupyter notebook'lar için yalnızca kod içeren hücreleri tuttuk. Ortaya çıkan kod, Hugging Face Hub'da [`smangrul/hf-stack-v1`](https://huggingface.co/datasets/smangrul/hf-stack-v1) bağlantısı altında bulabileceğiniz bir veri seti olarak mevcut. Bu veri seti repo'nun kimliğini, dosya yolunu ve dosya içeriğini içeriyor.\n",
    "\n",
    "\n",
    "## Model\n",
    "\n",
    "Bu rehber için 1 milyar parametreli ve 80'den fazla programlama dilinde eğitilmiş [`bigcode/starcoderbase-1b`](https://huggingface.co/bigcode/starcoderbase-1b) modelini seçiyoruz. Bu model, yayıncı tarafından korumaya sahip, bu nedenle bu notebook'u tam olarak bu modelle çalıştırmayı planlıyorsanız, modelin sayfasından erişim sağlamanız gerekir. Erişim izninizi aldıktan sonra, Hugging Face hesabınıza giriş yapın.\n",
    "\n",
    "**Not:** Eğer fine-tune edilmiş modelinizi Hugging Face Hub'a yüklemek istiyorsanız, `write` izni olan bir token girmeniz gerekli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bPlCJYDK6vrF"
   },
   "outputs": [],
   "source": [
    "from huggingface_hub import notebook_login\n",
    "\n",
    "notebook_login()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WMVe_c8q43Qo"
   },
   "source": [
    "Başlamak için gerekli tüm kütüphaneleri yükleyelim. Gördüğünüz gibi, `transformers` ve `datasets` kütüphanelerine ek olarak, eğitimi optimize etmek için `peft`, `bitsandbytes` ve `flash-attn` kullanacağız.\n",
    "\n",
    "Parametre açısından verimli eğitim teknikleri kullanarak, bu notebook'u tek bir A100 High-RAM GPU üzerinde çalıştırabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Fp7i8WMCjKJG"
   },
   "outputs": [],
   "source": [
    "!pip install -q transformers datasets peft bitsandbytes flash-attn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "16EdABzt3_Ig"
   },
   "source": [
    "Şimdi biraz hiperparametre tanımlayalım. Değerlerini istediğiniz gibi değiştirebilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hru3G-CLmqis"
   },
   "outputs": [],
   "source": [
    "MODEL=\"bigcode/starcoderbase-1b\" # Hugging Face Hub model adı\n",
    "DATASET=\"smangrul/hf-stack-v1\"   # Hugging Face Hub'daki veri seti\n",
    "DATA_COLUMN=\"content\"            # kod içeriğinin olduğu sütun adı\n",
    "\n",
    "SEQ_LENGTH=2048                  # Karakter uzunluğu\n",
    "\n",
    "# Eğitim argümanları\n",
    "MAX_STEPS=2000                   # max_steps\n",
    "BATCH_SIZE=16                    # batch_size\n",
    "GR_ACC_STEPS=1                   # gradient_accumulation_steps\n",
    "LR=5e-4                          # learning_rate\n",
    "LR_SCHEDULER_TYPE=\"cosine\"       # lr_scheduler_type\n",
    "WEIGHT_DECAY=0.01                # weight_decay\n",
    "NUM_WARMUP_STEPS=30              # num_warmup_steps\n",
    "EVAL_FREQ=100                    # eval_freq\n",
    "SAVE_FREQ=100                    # save_freq\n",
    "LOG_FREQ=25                      # log_freq\n",
    "OUTPUT_DIR=\"peft-starcoder-lora-a100\" # output_dir\n",
    "BF16=True                        # bf16\n",
    "FP16=False                       # no_fp16\n",
    "\n",
    "# FIM dönüşüm argümanları\n",
    "FIM_RATE=0.5                     # fim_rate\n",
    "FIM_SPM_RATE=0.5                 # fim_spm_rate\n",
    "\n",
    "# LORA argümanları\n",
    "LORA_R=8                         # lora_r\n",
    "LORA_ALPHA=32                    # lora_alpha\n",
    "LORA_DROPOUT=0.0                 # lora_dropout\n",
    "LORA_TARGET_MODULES=\"c_proj,c_attn,q_attn,c_fc,c_proj\"    # lora_target_modules\n",
    "\n",
    "# bitsandbytes config argümanları\n",
    "USE_NESTED_QUANT=True            # use_nested_quant\n",
    "BNB_4BIT_COMPUTE_DTYPE=\"bfloat16\"# bnb_4bit_compute_dtype\n",
    "\n",
    "SEED=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FyZSXTbJrcnC"
   },
   "outputs": [],
   "source": [
    "from transformers import (\n",
    "    AutoModelForCausalLM,\n",
    "    AutoTokenizer,\n",
    "    Trainer,\n",
    "    TrainingArguments,\n",
    "    logging,\n",
    "    set_seed,\n",
    "    BitsAndBytesConfig,\n",
    ")\n",
    "\n",
    "set_seed(SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pO7F5L5AtKo1"
   },
   "source": [
    "## Veri setinin hazırlanması"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1LmrIZqP0oUE"
   },
   "source": [
    "Verileri yükleyerek başlayalım. Veri setinin oldukça büyük olması muhtemel olduğundan, streaming modunu etkinleştirdiğinizden emin olun. \n",
    "\n",
    "Streaming modu, tüm veri setini bir kerede indirmek yerine veri seti üzerinde işlem yaptıkça verileri kademeli olarak yüklememizi sağlar.\n",
    "\n",
    "İlk 4000 örneği validation set (doğrulama kümesi) olarak ayıracağız ve geri kalan her şey eğitim verisi olacak."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4oJZvZb-1J88"
   },
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "\n",
    "\n",
    "dataset = load_dataset(\n",
    "    DATASET,\n",
    "    data_dir=\"data\",\n",
    "    split=\"train\",\n",
    "    streaming=True,\n",
    ")\n",
    "\n",
    "valid_data = dataset.take(4000)\n",
    "train_data = dataset.skip(4000)\n",
    "train_data = train_data.shuffle(buffer_size=5000, seed=SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sLQ8t0LM2GR6"
   },
   "source": [
    "Bu adımda, veri seti hala isteğe bağlı uzunlukta kod içeren ham veriler içeriyor. Eğitim için sabit uzunlukta girdilere ihtiyacımız var. Bir metin dosyası akışından (stream) sabit uzunlukta token yığınları döndürecek bir Iterable veri kümesi oluşturalım.\n",
    "\n",
    "İlk olarak, veri setindeki token başına ortalama karakter sayısını tahmin edelim, bu daha sonra text buffer'daki token sayısını tahmin etmemize yardımcı olacaktır. Varsayılan olarak, veri setinden yalnızca 400 örnek (`nb_examples`) alacağız. Tüm veri setinin yalnızca bir alt kümesini kullanmak, hesaplama maliyetini düşürürken, genel karakter-token oranının makul bir tahminini sağlayacaktır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KCiAvydztNsu",
    "outputId": "cabf7fd0-a922-4371-cbc6-60ee99ef7469"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [00:10<00:00, 39.87it/s] "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character to token ratio of the dataset is: 2.43\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)\n",
    "\n",
    "def chars_token_ratio(dataset, tokenizer, data_column, nb_examples=400):\n",
    "    \"\"\"\n",
    "    Veri kümesindeki token başına ortalama karakter sayısını tahmin eder.\n",
    "    \"\"\"\n",
    "\n",
    "    total_characters, total_tokens = 0, 0\n",
    "    for _, example in tqdm(zip(range(nb_examples), iter(dataset)), total=nb_examples):\n",
    "        total_characters += len(example[data_column])\n",
    "        total_tokens += len(tokenizer(example[data_column]).tokens())\n",
    "\n",
    "    return total_characters / total_tokens\n",
    "\n",
    "\n",
    "chars_per_token = chars_token_ratio(train_data, tokenizer, DATA_COLUMN)\n",
    "print(f\"The character to token ratio of the dataset is: {chars_per_token:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6F13VGobB3Ma"
   },
   "source": [
    "Karakter-token oranı, metin tokenizasyonunun kalitesinin bir göstergesi olarak da kullanılabilir. Örneğin, karakter-token oranının 1,0 olması her karakterin bir token ile temsil edildiği anlamına gelir ki bu çok anlamlı değildir. Bu da zayıf bir tokenizasyona işaret eder. Standart İngilizce metinde bir token tipik olarak yaklaşık dört karaktere eşdeğerdir, yani karakter-token oranı 4,0 civarındadır. Kod veri setinde daha düşük bir oran bekleyebiliriz, ancak genel olarak konuşursak, 2,0 ile 3,5 arasında bir sayı yeterince iyi kabul edilebilir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rcwYFRPpwxea"
   },
   "source": [
    "**Opsiyonel FIM dönüşümleri**\n",
    "\n",
    "Autoregressive dil modelleri tipik olarak soldan sağa doğru sekanslar üretir. Model, FIM dönüşümlerini uygulayarak metni doldurmayı da öğrenebilir.  Teknik hakkında daha fazla bilgi edinmek için [“Efficient Training of Language Models to Fill in the Middle” makalesine](https://arxiv.org/pdf/2207.14255.pdf) göz atın.\n",
    "\n",
    "FIM dönüşümlerini burada tanımlayacağız ve Iterable veri setini oluştururken bunları kullanacağız. Ancak, dönüşümleri kullanmak istemiyorsanız, `fim_rate` değerini 0 olarak ayarlayabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zmejYvEKw1E-"
   },
   "outputs": [],
   "source": [
    "import functools\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# FIM dönüşümleri için önek, sonek ve orta için özel belirteçlerin belirteç kimliklerini almak için yardımcı fonksiyon.\n",
    "@functools.lru_cache(maxsize=None)\n",
    "def get_fim_token_ids(tokenizer):\n",
    "    try:\n",
    "        FIM_PREFIX, FIM_MIDDLE, FIM_SUFFIX, FIM_PAD = tokenizer.special_tokens_map[\"additional_special_tokens\"][1:5]\n",
    "        suffix_tok_id, prefix_tok_id, middle_tok_id, pad_tok_id = (\n",
    "            tokenizer.vocab[tok] for tok in [FIM_SUFFIX, FIM_PREFIX, FIM_MIDDLE, FIM_PAD]\n",
    "        )\n",
    "    except KeyError:\n",
    "        suffix_tok_id, prefix_tok_id, middle_tok_id, pad_tok_id = None, None, None, None\n",
    "    return suffix_tok_id, prefix_tok_id, middle_tok_id, pad_tok_id\n",
    "\n",
    "\n",
    "# https://github.com/bigcode-project/Megatron-LM/blob/6c4bf908df8fd86b4977f54bf5b8bd4b521003d1/megatron/data/gpt_dataset.py adresinden uyarlanmıştır.\n",
    "def permute(\n",
    "    sample,\n",
    "    np_rng,\n",
    "    suffix_tok_id,\n",
    "    prefix_tok_id,\n",
    "    middle_tok_id,\n",
    "    pad_tok_id,\n",
    "    fim_rate=0.5,\n",
    "    fim_spm_rate=0.5,\n",
    "    truncate_or_pad=False,\n",
    "):\n",
    "    \"\"\"\n",
    "    Bir örnek (token listesi) alarak iki FIM modu yardımıyla fim_rate olasılığı ile bir FIM dönüşümü gerçekleştirir:\n",
    "    PSM ve SPM (fim_spm_rate olasılığı ile).\n",
    "    \"\"\"\n",
    "\n",
    "    # if koşulu fim_rate olasılığı ile tetiklenecektir\n",
    "    # Bu, FIM dönüşümlerinin fim_rate olasılığına sahip örneklere uygulanacağı anlamına gelir\n",
    "    if np_rng.binomial(1, fim_rate):\n",
    "\n",
    "        # boundaries dizisinde saklanan rastgele oluşturulmuş indekslere göre örneği önek, orta ve sonek olarak ayırır.\n",
    "        boundaries = list(np_rng.randint(low=0, high=len(sample) + 1, size=2))\n",
    "        boundaries.sort()\n",
    "\n",
    "        prefix = np.array(sample[: boundaries[0]], dtype=np.int64)\n",
    "        middle = np.array(sample[boundaries[0] : boundaries[1]], dtype=np.int64)\n",
    "        suffix = np.array(sample[boundaries[1] :], dtype=np.int64)\n",
    "\n",
    "        if truncate_or_pad:\n",
    "            # önek, orta ve sonek belirten tokenleri dikkate alarak örneğin yeni toplam uzunluğunu hesaplar\n",
    "            new_length = suffix.shape[0] + prefix.shape[0] + middle.shape[0] + 3\n",
    "            diff = new_length - len(sample)\n",
    "\n",
    "            # yeni uzunluk ile orijinal uzunluk arasında bir uzunluk farkı varsa aktarma veya kesme\n",
    "            if diff > 0:\n",
    "                if suffix.shape[0] <= diff:\n",
    "                    return sample, np_rng\n",
    "                suffix = suffix[: suffix.shape[0] - diff]\n",
    "            elif diff < 0:\n",
    "                suffix = np.concatenate([suffix, np.full((-1 * diff), pad_tok_id)])\n",
    "\n",
    "        # FIM dönüşümlerinin fim_spm_rateapply SPM varyantının olasılığı ile\n",
    "        # SPM: sonek, önek, orta\n",
    "        if np_rng.binomial(1, fim_spm_rate):\n",
    "            new_sample = np.concatenate(\n",
    "                [\n",
    "                    [prefix_tok_id, suffix_tok_id],\n",
    "                    suffix,\n",
    "                    [middle_tok_id],\n",
    "                    prefix,\n",
    "                    middle,\n",
    "                ]\n",
    "            )\n",
    "        # Aksi takdirde, FIM dönüşümlerinin PSM varyantını uygulayın\n",
    "        # PSM: önek, sonek, orta\n",
    "        else:\n",
    "\n",
    "            new_sample = np.concatenate(\n",
    "                [\n",
    "                    [prefix_tok_id],\n",
    "                    prefix,\n",
    "                    [suffix_tok_id],\n",
    "                    suffix,\n",
    "                    [middle_tok_id],\n",
    "                    middle,\n",
    "                ]\n",
    "            )\n",
    "    else:\n",
    "        # FIM dönüşümlerini uygulamama\n",
    "        new_sample = sample\n",
    "\n",
    "    return list(new_sample), np_rng\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AwW5FviD9xBH"
   },
   "source": [
    "Sabit uzunlukta token yığınları döndürecek bir Iterable veri seti olan `ConstantLengthDataset`'i tanımlayalım. Bunu yapmak için, boyut sınırlarına ulaşana kadar orijinal veri setinden bir buffer metin okuyacağız ve ardından ham metni tokenize edilmiş girdilere dönüştürmek için tokenizer uygulayacağız. İsteğe bağlı olarak, bazı diziler üzerinde FIM dönüşümleri gerçekleştireceğiz (etkilenen dizilerin oranı `fim_rate` tarafından kontrol edilir).\n",
    "\n",
    "Tanımlandıktan sonra, hem eğitim hem de doğrulama verilerinden `ConstantLengthDataset` örnekleri oluşturabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AgDW-692wzOl"
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import IterableDataset\n",
    "from torch.utils.data.dataloader import DataLoader\n",
    "import random\n",
    "\n",
    "# Bir metin dosyası akışından sabit uzunlukta token parçaları döndüren bir Iterable veri seti oluşturur.\n",
    "\n",
    "class ConstantLengthDataset(IterableDataset):\n",
    "    \"\"\"\n",
    "    Metin dosyalarının akışından sabit uzunlukta token parçaları döndüren yinelenebilir veri seti.\n",
    "        Argümanlar:\n",
    "            tokenizer (Tokenizer): Verileri işlemek için kullanılan işleyicidir.\n",
    "            veri seti (dataset.Dataset): Metin dosyaları içeren veri seti.\n",
    "            infinite (bool): True ise, veri seti sona ulaştıktan sonra iterator sıfırlanır, aksi takdirde durur.\n",
    "            seq_length (int): Döndürülecek token sekanslarının uzunluğu.\n",
    "            num_of_sequences (int): Buffer'da tutulacak token sequence sayısı.\n",
    "            chars_per_token (int): Metin buffer'ındaki token sayısını tahmin etmek için kullanılan token başına karakter sayısı.\n",
    "            fim_rate (float): Numunenin FIM ile permüle edileceği oran (0,0 ila 1,0).\n",
    "            fim_spm_rate (float): SPM kullanacak FIM permütasyonlarının oranı (0.0 ila 1.0).\n",
    "            seed (int): Rastgele sayı üreteci için seed.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        tokenizer,\n",
    "        dataset,\n",
    "        infinite=False,\n",
    "        seq_length=1024,\n",
    "        num_of_sequences=1024,\n",
    "        chars_per_token=3.6,\n",
    "        content_field=\"content\",\n",
    "        fim_rate=0.5,\n",
    "        fim_spm_rate=0.5,\n",
    "        seed=0,\n",
    "    ):\n",
    "        self.tokenizer = tokenizer\n",
    "        self.concat_token_id = tokenizer.eos_token_id\n",
    "        self.dataset = dataset\n",
    "        self.seq_length = seq_length\n",
    "        self.infinite = infinite\n",
    "        self.current_size = 0\n",
    "        self.max_buffer_size = seq_length * chars_per_token * num_of_sequences\n",
    "        self.content_field = content_field\n",
    "        self.fim_rate = fim_rate\n",
    "        self.fim_spm_rate = fim_spm_rate\n",
    "        self.seed = seed\n",
    "\n",
    "        (\n",
    "            self.suffix_tok_id,\n",
    "            self.prefix_tok_id,\n",
    "            self.middle_tok_id,\n",
    "            self.pad_tok_id,\n",
    "        ) = get_fim_token_ids(self.tokenizer)\n",
    "        if not self.suffix_tok_id and self.fim_rate > 0:\n",
    "            print(\"FIM is not supported by tokenizer, disabling FIM\")\n",
    "            self.fim_rate = 0\n",
    "\n",
    "    def __iter__(self):\n",
    "        iterator = iter(self.dataset)\n",
    "        more_examples = True\n",
    "        np_rng = np.random.RandomState(seed=self.seed)\n",
    "        while more_examples:\n",
    "            buffer, buffer_len = [], 0\n",
    "            while True:\n",
    "                if buffer_len >= self.max_buffer_size:\n",
    "                    break\n",
    "                try:\n",
    "                    buffer.append(next(iterator)[self.content_field])\n",
    "                    buffer_len += len(buffer[-1])\n",
    "                except StopIteration:\n",
    "                    if self.infinite:\n",
    "                        iterator = iter(self.dataset)\n",
    "                    else:\n",
    "                        more_examples = False\n",
    "                        break\n",
    "            tokenized_inputs = self.tokenizer(buffer, truncation=False)[\"input_ids\"]\n",
    "            all_token_ids = []\n",
    "\n",
    "            for tokenized_input in tokenized_inputs:\n",
    "                # opsiyonel FIM permütasyonları\n",
    "                if self.fim_rate > 0:\n",
    "                    tokenized_input, np_rng = permute(\n",
    "                        tokenized_input,\n",
    "                        np_rng,\n",
    "                        self.suffix_tok_id,\n",
    "                        self.prefix_tok_id,\n",
    "                        self.middle_tok_id,\n",
    "                        self.pad_tok_id,\n",
    "                        fim_rate=self.fim_rate,\n",
    "                        fim_spm_rate=self.fim_spm_rate,\n",
    "                        truncate_or_pad=False,\n",
    "                    )\n",
    "\n",
    "                all_token_ids.extend(tokenized_input + [self.concat_token_id])\n",
    "            examples = []\n",
    "            for i in range(0, len(all_token_ids), self.seq_length):\n",
    "                input_ids = all_token_ids[i : i + self.seq_length]\n",
    "                if len(input_ids) == self.seq_length:\n",
    "                    examples.append(input_ids)\n",
    "            random.shuffle(examples)\n",
    "            for example in examples:\n",
    "                self.current_size += 1\n",
    "                yield {\n",
    "                    \"input_ids\": torch.LongTensor(example),\n",
    "                    \"labels\": torch.LongTensor(example),\n",
    "                }\n",
    "\n",
    "\n",
    "train_dataset = ConstantLengthDataset(\n",
    "        tokenizer,\n",
    "        train_data,\n",
    "        infinite=True,\n",
    "        seq_length=SEQ_LENGTH,\n",
    "        chars_per_token=chars_per_token,\n",
    "        content_field=DATA_COLUMN,\n",
    "        fim_rate=FIM_RATE,\n",
    "        fim_spm_rate=FIM_SPM_RATE,\n",
    "        seed=SEED,\n",
    ")\n",
    "eval_dataset = ConstantLengthDataset(\n",
    "        tokenizer,\n",
    "        valid_data,\n",
    "        infinite=False,\n",
    "        seq_length=SEQ_LENGTH,\n",
    "        chars_per_token=chars_per_token,\n",
    "        content_field=DATA_COLUMN,\n",
    "        fim_rate=FIM_RATE,\n",
    "        fim_spm_rate=FIM_SPM_RATE,\n",
    "        seed=SEED,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rxev1sk6tRW9"
   },
   "source": [
    "## Modelin Hazırlanması"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UCtWV-U42Eq_"
   },
   "source": [
    "Veriler hazırlandığına göre, şimdi modeli yükleme zamanı! Modelin kuantize edilmiş versiyonunu yükleyeceğiz.\n",
    "\n",
    "Kuantizasyon verileri daha az bitle temsil ettiğinden bellek kullanımını azaltmamızı sağlar. Modeli kuantize etmek için `transformers` ile güzel bir entegrasyona sahip `bitsandbytes` kütüphanesini kullanacağız. Tek yapmamız gereken bir `bitsandbytes` config tanımlamak ve ardından modeli yüklerken bunu kullanmak.\n",
    "\n",
    "4 bit kuantizasyonun farklı varyantları vardır, ancak genellikle daha iyi performans için NF4 kuantizasyonu kullanmanızı öneririz (`bnb_4bit_quant_type=“nf4”`).\n",
    "\n",
    "`bnb_4bit_use_double_quant` seçeneği, parametre başına ek 0,4 bit tasarruf etmek için ilkinden sonra ikinci bir kuantizasyon ekler.\n",
    "\n",
    "Niceleme hakkında daha fazla bilgi edinmek için [“Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA” blog post](https://huggingface.co/blog/4bit-transformers-bitsandbytes) adresine göz atın.\n",
    "\n",
    "Tanımlandıktan sonra, modelin kuantize edilmiş versiyonunu yüklemek için yapılandırmayı `from_pretrained` metoduna aktarın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XuwoX6U2DUvK"
   },
   "outputs": [],
   "source": [
    "from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\n",
    "from peft.tuners.lora import LoraLayer\n",
    "\n",
    "load_in_8bit = False\n",
    "\n",
    "# 4-bit kuantize işlemi\n",
    "compute_dtype = getattr(torch, BNB_4BIT_COMPUTE_DTYPE)\n",
    "\n",
    "bnb_config = BitsAndBytesConfig(\n",
    "    load_in_4bit=True,\n",
    "    bnb_4bit_quant_type=\"nf4\",\n",
    "    bnb_4bit_compute_dtype=compute_dtype,\n",
    "    bnb_4bit_use_double_quant=USE_NESTED_QUANT,\n",
    ")\n",
    "\n",
    "device_map = {\"\": 0}\n",
    "\n",
    "model = AutoModelForCausalLM.from_pretrained(\n",
    "        MODEL,\n",
    "        load_in_8bit=load_in_8bit,\n",
    "        quantization_config=bnb_config,\n",
    "        device_map=device_map,\n",
    "        use_cache=False,  # Gradient Checkpoint kullanacağız\n",
    "        trust_remote_code=True,\n",
    "        use_flash_attention_2=True,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bO9e2FV8D8ZF"
   },
   "source": [
    "Eğitim için kuantize edilmiş bir model kullanırken, modeli ön işleme tabi tutmak amacıyla `prepare_model_for_kbit_training()` fonksiyonunu çağırmamız gerekiyor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Qb_eB4xzEDBk"
   },
   "outputs": [],
   "source": [
    "model = prepare_model_for_kbit_training(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lmnLjPZpDVtg"
   },
   "source": [
    "Artık kuantize model hazır olduğuna göre, bir LoRA yapılandırması ayarlayabiliriz. LoRA, eğitilebilir parametrelerin sayısını önemli ölçüde azaltarak fine-tune yapmayı daha verimli hale getirir.\n",
    "\n",
    "LoRA tekniğini kullanarak bir modeli eğitmek için, temel modeli `PeftModel` olarak çağırmamız gerekir. Bu, `LoraConfig` ile LoRA yapılandırmasını tanımlamayı ve `LoraConfig` kullanarak orijinal modeli `get_peft_model()` ile çağırmayı içerir.\n",
    "\n",
    "LoRA ve parametreleri hakkında daha fazla bilgi edinmek için [PEFT dokümantasyonuna](https://huggingface.co/docs/peft/conceptual_guides/lora) bakabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_pAUU2FR2Gey",
    "outputId": "63328c2b-e693-49b1-ce0a-3ca8722f852a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trainable params: 5,554,176 || all params: 1,142,761,472 || trainable%: 0.4860310866343243\n"
     ]
    }
   ],
   "source": [
    "# Lora config ayarları\n",
    "peft_config = LoraConfig(\n",
    "    lora_alpha=LORA_ALPHA,\n",
    "    lora_dropout=LORA_DROPOUT,\n",
    "    r=LORA_R,\n",
    "    bias=\"none\",\n",
    "    task_type=\"CAUSAL_LM\",\n",
    "    target_modules=LORA_TARGET_MODULES.split(\",\"),\n",
    ")\n",
    "\n",
    "model = get_peft_model(model, peft_config)\n",
    "model.print_trainable_parameters()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tHe7AElXzXVV"
   },
   "source": [
    "Gördüğünüz gibi LoRA tekniğini uyguladığımızda artık parametrelerin %1'inden daha azını eğitmemiz gerekecek."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T_CqVydc40IM"
   },
   "source": [
    "## Modelin Eğitilmesi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q_iN2khjrbD3"
   },
   "source": [
    "Artık verileri hazırladığımıza ve modeli optimize ettiğimize göre, eğitimi başlatmak için her şeyi bir araya getirmeye hazırız.\n",
    "\n",
    "Bir `Trainer` objesi oluşturmak için, eğitim konfigürasyonu tanımlamamız gerekiyor. En önemlisi, eğitimi yapılandırmak için tüm öznitelikleri içeren bir sınıf olan `TrainingArguments`'tır.\n",
    "\n",
    "Bunlar, çalıştırabileceğiniz diğer tüm model eğitimlerine benziyor, bu nedenle burada ayrıntılara girmeyeceğiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "65QHS8l1tKQe"
   },
   "outputs": [],
   "source": [
    "train_data.start_iteration = 0\n",
    "\n",
    "\n",
    "training_args = TrainingArguments(\n",
    "    output_dir=f\"Your_HF_username/{OUTPUT_DIR}\",\n",
    "    dataloader_drop_last=True,\n",
    "    evaluation_strategy=\"steps\",\n",
    "    save_strategy=\"steps\",\n",
    "    max_steps=MAX_STEPS,\n",
    "    eval_steps=EVAL_FREQ,\n",
    "    save_steps=SAVE_FREQ,\n",
    "    logging_steps=LOG_FREQ,\n",
    "    per_device_train_batch_size=BATCH_SIZE,\n",
    "    per_device_eval_batch_size=BATCH_SIZE,\n",
    "    learning_rate=LR,\n",
    "    lr_scheduler_type=LR_SCHEDULER_TYPE,\n",
    "    warmup_steps=NUM_WARMUP_STEPS,\n",
    "    gradient_accumulation_steps=GR_ACC_STEPS,\n",
    "    gradient_checkpointing=True,\n",
    "    fp16=FP16,\n",
    "    bf16=BF16,\n",
    "    weight_decay=WEIGHT_DECAY,\n",
    "    push_to_hub=True,\n",
    "    include_tokens_per_second=True,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kB_fLRex09ut"
   },
   "source": [
    "Son adım olarak `Trainer` objesini oluşturun ve `train` metodunu çağırın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "rS3nVwhUC69O",
    "outputId": "61a5bdb2-b7d0-4aed-8290-4bf20c2ccd38"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training...\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='2000' max='2000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [2000/2000 4:16:10, Epoch 1/9223372036854775807]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Step</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>100</td>\n",
       "      <td>5.524600</td>\n",
       "      <td>7.456872</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>200</td>\n",
       "      <td>5.617800</td>\n",
       "      <td>7.262190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>300</td>\n",
       "      <td>5.129100</td>\n",
       "      <td>6.410039</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>400</td>\n",
       "      <td>5.052200</td>\n",
       "      <td>6.306774</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>500</td>\n",
       "      <td>5.202900</td>\n",
       "      <td>6.117062</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>600</td>\n",
       "      <td>4.654100</td>\n",
       "      <td>6.018349</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>700</td>\n",
       "      <td>5.100200</td>\n",
       "      <td>6.000355</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>800</td>\n",
       "      <td>5.049800</td>\n",
       "      <td>5.889457</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>900</td>\n",
       "      <td>4.541200</td>\n",
       "      <td>5.813823</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1000</td>\n",
       "      <td>5.000700</td>\n",
       "      <td>5.834208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1100</td>\n",
       "      <td>5.026500</td>\n",
       "      <td>5.781939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1200</td>\n",
       "      <td>4.411800</td>\n",
       "      <td>5.720596</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1300</td>\n",
       "      <td>4.782500</td>\n",
       "      <td>5.736376</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1400</td>\n",
       "      <td>4.980200</td>\n",
       "      <td>5.712276</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1500</td>\n",
       "      <td>4.368700</td>\n",
       "      <td>5.689637</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1600</td>\n",
       "      <td>4.884700</td>\n",
       "      <td>5.675920</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1700</td>\n",
       "      <td>4.914400</td>\n",
       "      <td>5.662421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1800</td>\n",
       "      <td>4.248700</td>\n",
       "      <td>5.660122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1900</td>\n",
       "      <td>4.798400</td>\n",
       "      <td>5.664026</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2000</td>\n",
       "      <td>4.704200</td>\n",
       "      <td>5.655665</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "TrainOutput(global_step=2000, training_loss=4.885598585128784, metrics={'train_runtime': 15380.3075, 'train_samples_per_second': 2.081, 'train_steps_per_second': 0.13, 'train_tokens_per_second': 4261.033, 'total_flos': 4.0317260660736e+17, 'train_loss': 4.885598585128784, 'epoch': 1.0})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer = Trainer(\n",
    "    model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset\n",
    ")\n",
    "\n",
    "print(\"Training...\")\n",
    "trainer.train()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aAERlCnt1PEW"
   },
   "source": [
    "Fine-tune edilmiş modelinizi Hugging Face Hub hesabınıza yükleyebilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1h7_AUTTDwE1"
   },
   "outputs": [],
   "source": [
    "trainer.push_to_hub()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KBVH7uFOM_UF"
   },
   "source": [
    "## Inference\n",
    "\n",
    "Model Hub'a yüklendikten sonra, inference için kullanılabilir. Bunu yapmak için önce orijinal temel modeli ve onun tokenizer'ını başlatırız. Sonra, fine-tune edilmiş ağırlıkları temel modelle birleştirmemiz gerekir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jtL37piINBFe"
   },
   "outputs": [],
   "source": [
    "from peft import PeftModel\n",
    "import torch\n",
    "\n",
    "# önce orijinal modeli yükleyin\n",
    "tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)\n",
    "base_model = AutoModelForCausalLM.from_pretrained(\n",
    "    MODEL,\n",
    "    quantization_config=None,\n",
    "    device_map=None,\n",
    "    trust_remote_code=True,\n",
    "    torch_dtype=torch.bfloat16,\n",
    ").cuda()\n",
    "\n",
    "# fine-tune edilmiş ağırlıkları orijinal model ile birleştirin\n",
    "peft_model_id = f\"Your_HF_username/{OUTPUT_DIR}\"\n",
    "model = PeftModel.from_pretrained(base_model, peft_model_id)\n",
    "model.merge_and_unload()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3USQ2suvDi9M"
   },
   "source": [
    "Şimdi inference için birleştirilmiş modeli kullanabiliriz. Kolaylık olması açısından, bir `get_code_completion` tanımlayacağız - metin oluşturma parametreleriyle deneme yapmaktan çekinmeyin :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RoTGpNbjDeWI"
   },
   "outputs": [],
   "source": [
    "def get_code_completion(prefix, suffix):\n",
    "    text = prompt = f\"\"\"<fim_prefix>{prefix}<fim_suffix>{suffix}<fim_middle>\"\"\"\n",
    "    model.eval()\n",
    "    outputs = model.generate(\n",
    "        input_ids=tokenizer(text, return_tensors=\"pt\").input_ids.cuda(),\n",
    "        max_new_tokens=128,\n",
    "        temperature=0.2,\n",
    "        top_k=50,\n",
    "        top_p=0.95,\n",
    "        do_sample=True,\n",
    "        repetition_penalty=1.0,\n",
    "    )\n",
    "    return tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0kMJiGDfDrBf"
   },
   "source": [
    "Şimdi, kodun tamamlanmasını sağlamak için yapmamız gereken tek şey `get_code_complete` fonksiyonunu çağırmak ve tamamlanmasını istediğimiz ilk birkaç satırı önek olarak, boş bir dizeyi de sonek olarak geçirmek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nXlco2_-YcvM",
    "outputId": "41c411ad-b7dc-4277-f975-c173888234bb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "from peft import LoraConfig, TaskType, get_peft_model\n",
      "from transformers import AutoModelForCausalLM\n",
      "peft_config = LoraConfig(\n",
      "    task_type=TaskType.CAUSAL_LM,\n",
      "    r=8,\n",
      "    lora_alpha=32,\n",
      "    target_modules=[\"q_proj\", \"v_proj\"],\n",
      "    lora_dropout=0.1,\n",
      "    bias=\"none\",\n",
      "    modules_to_save=[\"q_proj\", \"v_proj\"],\n",
      "    inference_mode=False,\n",
      ")\n",
      "model = AutoModelForCausalLM.from_pretrained(\"gpt2\")\n",
      "model = get_peft_model(model, peft_config)\n",
      "model.print_trainable_parameters()\n"
     ]
    }
   ],
   "source": [
    "prefix = \"\"\"from peft import LoraConfig, TaskType, get_peft_model\n",
    "from transformers import AutoModelForCausalLM\n",
    "peft_config = LoraConfig(\n",
    "\"\"\"\n",
    "suffix =\"\"\"\"\"\"\n",
    "\n",
    "print(get_code_completion(prefix, suffix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ql2563kGlnmu"
   },
   "source": [
    "Bu notebook'ta daha önce PEFT kütüphanesini kullanmış biri olarak, `LoraConfig` oluşturmak için üretilen sonucun oldukça iyi olduğunu görebilirsiniz!\n",
    "\n",
    "Modeli inference için başlattığımız hücreye geri dönersek ve fine-tune edilmiş ağırlıkları birleştirdiğimiz satırları yorum satırı yaparsak, orijinal modelin tam olarak aynı önek için ne üreteceğini görebilirsiniz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "29xxp1eHTgJ9",
    "outputId": "c6d597a2-01da-4d25-a32f-3a551212c5b4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "from peft import LoraConfig, TaskType, get_peft_model\n",
      "from transformers import AutoModelForCausalLM\n",
      "peft_config = LoraConfig(\n",
      "    model_name_or_path=\"facebook/wav2vec2-base-960h\",\n",
      "    num_labels=1,\n",
      "    num_features=1,\n",
      "    num_hidden_layers=1,\n",
      "    num_attention_heads=1,\n",
      "    num_hidden_layers_per_attention_head=1,\n",
      "    num_attention_heads_per_hidden_layer=1,\n",
      "    hidden_size=1024,\n",
      "    hidden_dropout_prob=0.1,\n",
      "    hidden_act=\"gelu\",\n",
      "    hidden_act_dropout_prob=0.1,\n",
      "    hidden\n"
     ]
    }
   ],
   "source": [
    "prefix = \"\"\"from peft import LoraConfig, TaskType, get_peft_model\n",
    "from transformers import AutoModelForCausalLM\n",
    "peft_config = LoraConfig(\n",
    "\"\"\"\n",
    "suffix =\"\"\"\"\"\"\n",
    "\n",
    "print(get_code_completion(prefix, suffix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pwy2ZC7U8Ema"
   },
   "source": [
    "Python syntax'ı olmasına rağmen, orijinal modelin `LoraConfig`'in ne yapması gerektiği konusunda hiçbir anlayışının olmadığını görebilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CATYE8pp2drQ"
   },
   "source": [
    "Bu tür fine-tune'ların tam bir fine-tune ile nasıl karşılaştırıldığını ve bu tür bir modeli VS Code'da Inference Endpoints veya yerel olarak co-pilot olarak nasıl kullanacağınızı öğrenmek için [\"Personal Copilot: Train Your Own Coding Assistant\" blog yazısına](https://huggingface.co/blog/personal-copilot) göz atın. Bu notebook orijinal blog yazısını tamamlar."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "A100",
   "machine_shape": "hm",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
